﻿using System;
using System.Collections;
using System.Collections.Generic;

namespace SLS.ExClassLib.Message
{
    public class ExMessageItem
    {
        public MessageEx msg;
        public ArrayList  NextItems;
        public ArrayList PreviousItems;
        public ArrayList AnswerItems;
        public string status;
       public  ExMessageItem()
        {
            
        }
        public ExMessageItem(MessageEx _msg)
        {
            msg = _msg;
            NextItems = new ArrayList();
            PreviousItems = new ArrayList();
            AnswerItems = new ArrayList();
            status = "NEW";
        }

    }
   public class ExMessagePool
    {
       public ExMessageItem msgItem;

       public SortedDictionary<string, ExMessageItem> MessageStock;
       public ExMessagePool()
       {
           MessageStock= new SortedDictionary<string, ExMessageItem>();
       }
       public void Add(MessageEx msg)
       {
           if (!MessageStock.ContainsKey(msg.MessageID))
           {
               msgItem = new ExMessageItem(msg);
               MessageStock.Add(msg.MessageID, msgItem);
           }
       }
       public void Remove(MessageEx msg)
       {
           MessageStock.Remove(msg.MessageID);
       }
       public MessageEx Reply(string MessageID, string Federation, string jobid, string updateFedtime = "NO")
       {
           //对msgA用msgB进行回复，新消息msgB将发送出去
           //当收到msgB的时候，表明msgA已经得到了回复
           MessageEx msgB=null;
           MessageEx msgA;      
           try
           {
               msgA = Find(MessageID);
               if (msgA == null)
               {
                   msgA = new MessageEx();
               }
               else
               {
                   msgB = new MessageEx(msgA);
               }
               msgB.Address = msgA.Address;
               msgB.Federation = Federation;
               msgB.JobID = jobid;
               msgB.Tag = updateFedtime; 
               if (!MessageStock.ContainsKey(msgB.MessageID))
               {
                   Add(msgB);
               }
               MessageStock[msgA.MessageID].NextItems.Add(msgB.MessageID);
               MessageStock[msgB.MessageID].PreviousItems.Add(msgA.MessageID);
           }
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
           return msgB;
       }
       public MessageEx Answer(MessageEx msgA,MessageEx msgB)
       { 
            ExMessageItem itemA=null,itemB=null;
           try
           {
               //当收到msgB的时候，表明msgA已经得到了回复
               if (MessageStock.ContainsKey(msgA.MessageID))
               {
                   itemA = MessageStock[msgA.MessageID];
               }
               if (itemA == null)
                   return msgB;

               if (!MessageStock.ContainsKey(msgB.MessageID))
               {
                   itemB = new ExMessageItem(msgB);
                   MessageStock.Add(msgB.MessageID, itemB);  
               }
               itemB = MessageStock[msgB.MessageID]; 
               itemA.AnswerItems.Add(msgB.MessageID);              
               if(!itemA.NextItems.Contains(msgB.MessageID))
               {
                   itemA.NextItems.Add(msgB.MessageID); 
                   itemB.PreviousItems.Add(msgA.MessageID);                  
               }
               if (itemA.NextItems.Count == itemA.AnswerItems.Count)
               {
                   itemA.status = "END";
               }
           }
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
           return msgB;
       }
       public void Clean()
       {
           try
           {
               ArrayList keys = new ArrayList();
               foreach (KeyValuePair<string,ExMessageItem> kpr in MessageStock)
               {
                   if (kpr.Value.status == "END")
                   {
                       keys.Add(kpr.Key);
                   }
               }
               foreach (string key in keys)
               {
                   MessageStock.Remove(key);
               }
           }             
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
       }
       public MessageEx Find(string MessageID)
       {
           MessageEx msg = null;
           try
           {
               if (MessageStock.ContainsKey(MessageID))
               {
                   msg = MessageStock[MessageID].msg;
               }
           }
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
           return msg;
       }
       public MessageEx FindNext(MessageEx msg)
       {
           MessageEx outmsg = null;
           try
           {
               ExMessageItem msgItem = MessageStock[msg.MessageID];
               if (msgItem != null)
               { 
                   foreach(string msgid in msgItem.NextItems)
                   {
                       outmsg = MessageStock[msgid].msg;
                   }               
               }
           }
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
           return outmsg;
       }
       public MessageEx FindPrevious(MessageEx msg)
       {
           MessageEx outmsg = null;
           try
           {
               ExMessageItem msgItem = MessageStock[msg.MessageID];
               if (msgItem != null)
               {
                   foreach (string msgid in msgItem.PreviousItems)
                   {
                       outmsg = MessageStock[msgid].msg;
                   }
               }
           }
           catch (Exception ex)
           {
               //Tracer.Error(ex.StackTrace, ex);
           }
           return outmsg;
       }
    }
}
